package com.demo.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/***
 * @author lqx
 * 为WEBSERVICE 准备 PDF的二进制流的字符串
 * 文件在 XXX转成二进制流的字符串，及将二进制流反转成PDF\PDFBinary.jar
 * xxx转成二进制流的字符串，及将二进制流反转成PDF\PDFBinary.jar
 */
public class PDFBinaryUtil {
    /*BASE64Encoder和BASE64Decoder这两个方法是sun公司的内部方法，并没有在java api中公开过，所以使用这些方法是不安全的，
     * 将来随时可能会从中去除，所以相应的应该使用替代的对象及方法，建议使用apache公司的API---可引用 import org.apache.commons.codec.binary.Base64;进行替换*/
    static BASE64Encoder encoder = new BASE64Encoder();
    static BASE64Decoder decoder = new BASE64Decoder();

    public static void main(String[] args) {
        //将PDF格式文件转成base64编码
        String base64String = getPDFBinary("D:\\hello.pdf");
        System.out.println(base64String);
        //将base64的编码转成PDF格式文件,，保存到XXX
        StringBuilder s=new StringBuilder();
        //s.append("JVBERi0xLjQKJeLjz9MKMyAwIG9iago8PC9Db2xvclNwYWNlL0RldmljZUdyYXkvU3VidHlwZS9J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");
        base64StringToPDF(s.toString(),"D:\\hello2.pdf");
    }

    /**
     *  将PDF转换成base64编码
     *  1.使用BufferedInputStream和FileInputStream从File指定的文件中读取内容；
     *  2.然后建立写入到ByteArrayOutputStream底层输出流对象的缓冲输出流BufferedOutputStream
     *  3.底层输出流转换成字节数组，然后由BASE64Encoder的对象对流进行编码
     * */
    public static String getPDFBinary(String filePath) {
        FileInputStream fin =null;
        BufferedInputStream bin =null;
        ByteArrayOutputStream baos = null;
        BufferedOutputStream bout =null;
        try {
            //建立读取文件的文件输出流
            fin = new FileInputStream(new File(filePath));
            //在文件输出流上安装节点流（更大效率读取）
            bin = new BufferedInputStream(fin);
            // 创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量
            baos = new ByteArrayOutputStream();
            //创建一个新的缓冲输出流，以将数据写入指定的底层输出流
            bout = new BufferedOutputStream(baos);
            byte[] buffer = new byte[1024];
            int len = bin.read(buffer);
            while(len != -1){
                bout.write(buffer, 0, len);
                len = bin.read(buffer);
            }
            //刷新此输出流并强制写出所有缓冲的输出字节，必须这行代码，否则有可能有问题
            bout.flush();
            byte[] bytes = baos.toByteArray();
            //sun公司的API
            return encoder.encodeBuffer(bytes).trim();
            //apache公司的API
            //return Base64.encodeBase64String(bytes);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fin.close();
                bin.close();
                //关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException
                //baos.close();
                bout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 将base64编码转换成PDF，保存到
     * @param base64sString
     * 1.使用BASE64Decoder对编码的字符串解码成字节数组
     *  2.使用底层输入流ByteArrayInputStream对象从字节数组中获取数据；
     *  3.建立从底层输入流中读取数据的BufferedInputStream缓冲输出流对象；
     *  4.使用BufferedOutputStream和FileOutputSteam输出数据到指定的文件中
     */
    public static void base64StringToPDF(String base64sString,String filePath){
        BufferedInputStream bin = null;
        FileOutputStream fout = null;
        BufferedOutputStream bout = null;
        try {
            //将base64编码的字符串解码成字节数组
            byte[] bytes = decoder.decodeBuffer(base64sString);
            //apache公司的API
            //byte[] bytes = Base64.decodeBase64(base64sString);
            //创建一个将bytes作为其缓冲区的ByteArrayInputStream对象
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            //创建从底层输入流中读取数据的缓冲输入流对象
            bin = new BufferedInputStream(bais);
            //指定输出的文件
            File file = new File(filePath);
            //创建到指定文件的输出流
            fout  = new FileOutputStream(file);
            //为文件输出流对接缓冲输出流对象
            bout = new BufferedOutputStream(fout);

            byte[] buffers = new byte[1024];
            int len = bin.read(buffers);
            while(len != -1){
                bout.write(buffers, 0, len);
                len = bin.read(buffers);
            }
            //刷新此输出流并强制写出所有缓冲的输出字节，必须这行代码，否则有可能有问题
            bout.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bin.close();
                fout.close();
                bout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
